#include "videocontroller.h"
#include <QDebug>
#include <QDateTime>
#include <thread>
#include <chrono>

// 构造函数：初始化成员变量
VideoController::VideoController(QObject *parent)
    : QObject{parent}, m_isRunning(false),  // 初始化运行状态为false
    m_cameraIndex(0), m_width(640), m_height(480),  // 初始化摄像头参数
    m_frameCounter(0)  // 初始化帧计数器
{
    // 初始化帧ID，包含时间戳确保唯一性
    m_frameId = QString("image://videoprovider/initial_%1").arg(QDateTime::currentMSecsSinceEpoch());
}

// 析构函数：停止视频聊天并清理资源
VideoController::~VideoController()
{
    stopVideoChat();
}

// 获取当前帧ID（供QML绑定）
QString VideoController::frameId() const
{
    std::lock_guard<std::mutex> lock(m_frameMutex);  // 加锁保证线程安全
    return m_frameId;
}

// 获取当前帧（供图像提供者调用）
QImage VideoController::getCurrentFrame() const
{
    std::lock_guard<std::mutex> lock(m_frameMutex);  // 加锁保证线程安全
    return m_currentFrame;
}

// 开始视频聊天
void VideoController::startVideoChat()
{
    if (m_isRunning) {  // 如果已在运行，直接返回状态
        emit statusChanged("视频聊天已在进行中");
        return;
    }

    // 先停止以确保资源释放
    stopVideoChat();

    try {
        // 尝试打开摄像头
        bool cameraOpened = false;

        // 尝试多个摄像头索引（0-4）
        for (int i = 0; i < 5; ++i) {
            m_capture.open(i);
            if (m_capture.isOpened()) {  // 如果成功打开
                cameraOpened = true;
                m_cameraIndex = i;
                qDebug() << "成功打开摄像头索引:" << i;
                break;
            }
        }

        if (!cameraOpened) {  // 如果所有摄像头都无法打开
            throw std::runtime_error("无法打开任何摄像头，请检查摄像头连接");
        }

        // 设置摄像头参数
        m_capture.set(cv::CAP_PROP_FRAME_WIDTH, m_width);
        m_capture.set(cv::CAP_PROP_FRAME_HEIGHT, m_height);
        m_capture.set(cv::CAP_PROP_FPS, 30);

        // 检查实际设置的分辨率
        double actualWidth = m_capture.get(cv::CAP_PROP_FRAME_WIDTH);
        double actualHeight = m_capture.get(cv::CAP_PROP_FRAME_HEIGHT);
        double actualFps = m_capture.get(cv::CAP_PROP_FPS);

        qDebug() << "摄像头参数 - 宽:" << actualWidth << "高:" << actualHeight << "FPS:" << actualFps;

        // 启动标志
        m_isRunning = true;

        // 启动捕获线程
        m_captureThread = std::thread(&VideoController::captureThreadFunc, this);

        emit statusChanged("视频聊天已启动");
    } catch (const std::exception &e) {  // 捕获异常并通知
        emit statusChanged(QString("启动失败: ") + e.what());
        cleanup();
    }
}

// 停止视频聊天
void VideoController::stopVideoChat()
{
    if (!m_isRunning) return;  // 如果未运行，直接返回

    // 停止标志
    m_isRunning = false;

    // 等待线程结束
    if (m_captureThread.joinable()) {
        m_captureThread.join();
    }

    // 清理资源
    cleanup();

    emit statusChanged("视频聊天已停止");
}

// 捕获线程函数：循环读取摄像头帧
void VideoController::captureThreadFunc()
{
    cv::Mat frame;  // OpenCV矩阵用于存储帧
    int frameCount = 0;  // 帧计数器
    auto lastTime = std::chrono::steady_clock::now();  // 用于计算帧率

    while (m_isRunning) {  // 循环直到停止标志为false
        if (m_capture.read(frame)) {  // 读取一帧
            if (!frame.empty()) {  // 如果帧不为空
                frameCount++;  // 计数

                // 计算时间差
                auto currentTime = std::chrono::steady_clock::now();
                auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(currentTime - lastTime).count();

                // 每秒重置一次计数器
                if (elapsed >= 1) {
                    frameCount = 0;
                    lastTime = currentTime;
                }

                // 转换颜色空间（OpenCV默认BGR，转为RGB）
                cv::Mat rgbFrame;
                cv::cvtColor(frame, rgbFrame, cv::COLOR_BGR2RGB);

                // 转换为QImage（注意数据指针和步长）
                QImage image(rgbFrame.data,
                             rgbFrame.cols,
                             rgbFrame.rows,
                             rgbFrame.step,
                             QImage::Format_RGB888);

                // 更新帧（使用copy确保数据有效性）
                updateFrame(image.copy());

                // 发射视频帧捕获信号，用于网络传输
                emit videoFrameCaptured(image.copy());
            }
        } else {  // 读取失败
            qDebug() << "读取摄像头帧失败";
            emit statusChanged("摄像头读取失败");
            break;
        }

        // 控制帧率（约30fps）
        std::this_thread::sleep_for(std::chrono::milliseconds(33));
    }
}

// 更新当前帧并通知QML
void VideoController::updateFrame(const QImage &frame)
{
    std::lock_guard<std::mutex> lock(m_frameMutex);  // 加锁保证线程安全
    m_currentFrame = frame;  // 更新当前帧
    m_frameCounter++;  // 增加帧计数器
    // 更新帧ID，包含计数器和时间戳
    m_frameId = QString("image://videoprovider/frame_%1_%2").arg(m_frameCounter).arg(QDateTime::currentMSecsSinceEpoch());
    emit frameUpdated();  // 通知QML帧已更新
}

// 发送视频帧（供外部调用）
void VideoController::sendVideoFrame()
{
    std::lock_guard<std::mutex> lock(m_frameMutex);  // 加锁保证线程安全
    if (!m_currentFrame.isNull()) {  // 如果帧有效
        emit videoFrameCaptured(m_currentFrame);  // 发射捕获信号
    }
}

// 初始化VLC（暂未实现）
void VideoController::initializeVLC()
{
    // 暂时注释掉VLC部分
}

// 清理资源
void VideoController::cleanup()
{
    // 释放VLC资源（暂未实现）
    // if (m_player) {
    //     libvlc_media_player_stop(m_player);
    //     libvlc_media_player_release(m_player);
    //     m_player = nullptr;
    // }

    // if (m_vlcInstance) {
    //     libvlc_release(m_vlcInstance);
    //     m_vlcInstance = nullptr;
    // }

    // 释放摄像头
    if (m_capture.isOpened()) {
        m_capture.release();
    }

    // 重置当前帧
    std::lock_guard<std::mutex> lock(m_frameMutex);
    m_currentFrame = QImage();
    m_frameId = QString("image://videoprovider/stopped_%1").arg(QDateTime::currentMSecsSinceEpoch());
}
